import { computed, reactive, ref } from 'vue';
import { useRoute } from 'vue-router';
import { defineStore } from 'pinia';
import { useLoading } from '@sa/hooks';
import { SetupStoreId } from '@/enum';
import { useRouterPush } from '@/hooks/common/router';
import { fetchGetUserInfo, fetchLogin } from '@/service/api';
import { localStg } from '@/utils/storage';
import { $t } from '@/locales';
import { useRouteStore } from '../route';
import { useTabStore } from '../tab';
import { clearAuthStorage, getToken } from './shared';

/** 认证状态管理 处理用户登录、登出、权限验证等认证相关的状态管理 */
export const useAuthStore = defineStore(SetupStoreId.Auth, () => {
  const route = useRoute();
  const routeStore = useRouteStore();
  const tabStore = useTabStore();
  const { toLogin, redirectFromLogin } = useRouterPush(false);
  const { loading: loginLoading, startLoading, endLoading } = useLoading();

  // 存储用户token
  const token = ref(getToken());

  // 用户信息
  const userInfo: Api.Auth.UserInfo = reactive({
    userId: '',
    userName: '',
    roles: [], // 用户角色列表
    buttons: [] // 用户按钮权限列表
  });

  /** 判断是否为静态路由模式下的超级管理员 通过环境变量配置的静态超级管理员角色进行判断 */
  const isStaticSuper = computed(() => {
    const { VITE_AUTH_ROUTE_MODE, VITE_STATIC_SUPER_ROLE } = import.meta.env;

    return VITE_AUTH_ROUTE_MODE === 'static' && userInfo.roles.includes(VITE_STATIC_SUPER_ROLE);
  });

  /** 判断用户是否已登录 */
  const isLogin = computed(() => Boolean(token.value));

  /** 重置认证状态 清除认证相关的存储信息并重置状态 */
  async function resetStore() {
    const authStore = useAuthStore();

    clearAuthStorage();

    authStore.$reset();

    if (!route.meta.constant) {
      await toLogin();
    }

    tabStore.cacheTabs();
    routeStore.resetStore();
  }

  /**
   * 用户登录
   *
   * @param userName 用户名
   * @param password 密码
   * @param [redirect=true] 登录成功后是否重定向，默认为 true. Default is `true`
   */
  async function login(userName: string, password: string, redirect = true) {
    startLoading();

    const { data: loginToken, error } = await fetchLogin(userName, password);

    if (!error) {
      const pass = await loginByToken(loginToken);

      if (pass) {
        await redirectFromLogin(redirect);

        window.$notification?.success({
          title: $t('page.login.common.loginSuccess'),
          message: $t('page.login.common.welcomeBack', { userName: userInfo.userName }),
          duration: 4500
        });
      }
    } else {
      resetStore();
    }

    endLoading();
  }

  /**
   * 通过token进行登录
   *
   * @param loginToken 登录token信息
   * @returns 登录是否成功
   */
  async function loginByToken(loginToken: Api.Auth.LoginToken) {
    // 1. 将token存储到localStorage，后续请求需要在header中使用
    localStg.set('token', loginToken.accessToken);
    localStg.set('refreshToken', loginToken.refreshToken);

    // 2. 获取用户信息
    const pass = await getUserInfo();

    if (pass) {
      token.value = loginToken.accessToken;

      return true;
    }

    return false;
  }

  /**
   * 获取用户信息
   *
   * @returns 是否成功获取用户信息
   */
  async function getUserInfo() {
    const { data: info, error } = await fetchGetUserInfo();

    if (!error) {
      // 更新store中的用户信息
      Object.assign(userInfo, info);

      return true;
    }

    return false;
  }

  /** 初始化用户信息 在应用启动时检查token并获取用户信息 */
  async function initUserInfo() {
    const hasToken = getToken();

    if (hasToken) {
      const pass = await getUserInfo();

      if (!pass) {
        resetStore();
      }
    }
  }

  return {
    token,
    userInfo,
    isStaticSuper,
    isLogin,
    loginLoading,
    resetStore,
    login,
    initUserInfo
  };
});
